package com.suncky.frame.utils;

import android.text.TextUtils;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class CollectionUtils {

    /**
     * 数据集合是否为空
     * @param list
     * @return
     * @param <T>
     */
    public static <T> boolean isEmpty(Collection<T> list) {
        return list == null || list.isEmpty();
    }

    /**
     * map是否为空
     * @param map
     * @return
     * @param <K>
     * @param <V>
     */
    public static <K, V> boolean isEmpty(Map<K, V> map) {
        return map == null || isEmpty(map.keySet());
    }

    /**
     * 拆分字符串并添加到集合
     * @param srcStr 要拆分的字符串
     * @param dest   保存拆分后的字符串的集合
     * @param regex  分隔正则表达式, 参考{@link String#split(String)}
     * @return dest的引用
     */
    public static <T extends Collection<String>> T split(String srcStr, @NonNull T dest, @NonNull String regex) {
        if (!TextUtils.isEmpty(srcStr)) {
            dest.addAll(Arrays.asList(srcStr.split(regex)));
        }
        return dest;
    }

    /**
     * 拆分字符串并添加到列表
     * @param srcStr 要拆分的字符串
     * @param regex 分隔正则表达式, 参考{@link String#split(String)}
     * @return 拆分后的字符串列表,如果srcStr参数为空,返回空列表
     */
    public static List<String> split(String srcStr, @NonNull String regex) {
        return split(srcStr, new ArrayList<>(), regex);
    }

    /**
     * 拆分字符串并添加到数组
     * @param srcStr 要拆分的字符串
     * @param regex 分隔正则表达式, 参考{@link String#split(String)}
     * @return 拆分后的字符串数组
     */
    public static String[] spilt(String srcStr, @NonNull String regex) {
        if (srcStr == null) {
            return null;
        }
        return srcStr.split(regex);
    }

    /**
     * 分隔符接字符串集合中的所有元素
     * @param iterable 字符串集合
     * @param c 分隔符
     * @return 拼接后的字符串
     */
    public static String joinToString(Iterable<String> iterable, CharSequence c) {
        return joinToString(iterable, c,0);
    }

    /**
     * 分隔符接字符串集合中的元素
     * @param iterable 字符串集合
     * @param c 分隔符
     * @param start   起始元素索引(从0开始)
     * @return 拼接后的字符串
     */
    public static String joinToString(Iterable<String> iterable, CharSequence c, int start) {
        return joinToString(iterable, c, start, -1);
    }

    /**
     * 分隔符接字符串集合中的元素
     * @param iterable 字符串集合
     * @param c 分隔符
     * @param start   起始元素索引(从0开始)
     * @param count      拼接元素的数量(小于0时不限制数量)
     * @return 拼接后的字符串
     */
    public static String joinToString(Iterable<String> iterable, CharSequence c, int start, int count) {
        return joinTo(new StringBuilder(), iterable, c, start, count,null).toString();
    }


    /**
     * 分隔符接集合中的元素
     * @param iterable 字符串集合
     * @param c 分隔符
     * @param convertor  字符串转换器,将元素转化成用于拼接的字符串
     * @return 拼接后的字符串
     */
    public static <T> String joinToString(Iterable<T> iterable, CharSequence c, @Nullable JoinStringConvertor<T> convertor) {
        return joinToString(iterable, c, 0,convertor);
    }

    /**
     * 分隔符接集合中的元素
     * @param iterable 字符串集合
     * @param c 分隔符
     * @param start   起始元素索引(从0开始)
     * @param convertor  字符串转换器,将元素转化成用于拼接的字符串
     * @return 拼接后的字符串
     */
    public static <T> String joinToString(Iterable<T> iterable, CharSequence c, int start, @Nullable JoinStringConvertor<T> convertor) {
        return joinToString(iterable, c, start, -1,convertor);
    }

    /**
     * 分隔符接集合中的元素
     * @param iterable 字符串集合
     * @param c 分隔符
     * @param start   起始元素索引(从0开始)
     * @param count      拼接元素的数量(小于0时不限制数量)
     * @param convertor  字符串转换器,将元素转化成用于拼接的字符串
     * @return 拼接后的字符串
     */
    public static <T> String joinToString(Iterable<T> iterable, CharSequence c, int start, int count, @Nullable JoinStringConvertor<T> convertor) {
        return joinTo(new StringBuilder(), iterable, c, start, count,convertor).toString();
    }

    /**
     * 分隔符拼接集合中的所有元素
     *
     * @param appendable 拼接集合元素的Appendable实例
     * @param iterable 元素集合
     * @param c          分隔符号
     * @param convertor  字符串转换器,将元素转化成用于拼接的字符串
     * @return 拼接集合元素的Appendable实例
     */
    public static <T> Appendable joinTo(@NonNull Appendable appendable, Iterable<T> iterable, CharSequence c, @Nullable JoinStringConvertor<T> convertor) {
        return joinTo(appendable, iterable, c, 0, convertor);
    }

    /**
     * 分隔符拼接集合中的所有元素
     *
     * @param appendable 拼接集合元素的Appendable实例
     * @param iterable 元素集合
     * @param c          分隔符号
     * @param start      起始元素索引(从0开始)
     * @param convertor  字符串转换器,将元素转化成用于拼接的字符串
     * @return 拼接集合元素的Appendable实例
     */
    public static <T> Appendable joinTo(@NonNull Appendable appendable, Iterable<T> iterable, CharSequence c, int start, @Nullable JoinStringConvertor<T> convertor) {
        return joinTo(appendable, iterable, c, start, -1, convertor);
    }


    /**
     * 分隔符拼接集合中的元素
     *
     * @param appendable 组个集合元素的Appendable实例
     * @param iterable   元素集合
     * @param c          分隔符号
     * @param start      起始元素索引(从0开始)
     * @param count      拼接元素的数量(小于0时不限制数量)
     * @param convertor  字符串转换器,将元素转化成用于拼接的字符串
     * @return 拼接集合元素的Appendable实例
     */
    public static <T> Appendable joinTo(@NonNull Appendable appendable, Iterable<T> iterable, CharSequence c, int start, int count, @Nullable JoinStringConvertor<T> convertor) {
        if (iterable == null || !iterable.iterator().hasNext()) {
            return appendable;
        }
        if (convertor == null) {
            convertor = new JoinStringConvertor<T>() {
                @Override
                public String convert(T o) {
                    return o.toString();
                }
            };
        }
        if (start < 0) {
            start = 0;
        }
        try {
            int elementIndex = 0;//当前遍历的元素序号
            int joinCount = 0;//已组合的元素数量(不计空元素)
            for (T o : iterable) {
                if (elementIndex < start) {
                    ++elementIndex;
                    continue;
                }
                //count小于0时不限制组合元素的数量
                if (count >= 0 && elementIndex - start >= count) {
                    break;
                }
                if (o == null) {
                    ++elementIndex;
                    continue;
                }
                if (c != null && c.length() > 0 && joinCount > 0) {
                    appendable.append(c);
                }
                appendable.append(convertor.convert(o));
                ++elementIndex;
                ++joinCount;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return appendable;
    }

    public interface JoinStringConvertor<T>{
       @Nullable String convert(T o);
    }

}
